package com.lollipop.synthential.concurrency.thread;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * @Author: J.K
 * @Date: 2020-07-03 15:14
 * @Description: 基于数组实现的线程池
 * 基于数组实现，在ArrayBlockingQueue内部，维护了一个定长数组，以便缓存队列中的数据对象，
 * 这是一个常用的阻塞队列，除了一个定长数组外，ArrayBlockingQueue内部还保存着两个整形变量，分别标识着队列的头部和尾部在数组中的位置。
 */
public class ThreadPool_01 {
    /**
     * 定义阻塞队列大小
     */
    private static final int maxSize = 5;

    public static void main(String[] args) {
        ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<>(maxSize);
        new Thread(new Productor(queue)).start();
        new Thread(new Customer(queue)).start();
    }
}

class Customer implements Runnable {
    private BlockingQueue<Integer> queue;

    Customer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        this.cusume();
    }

    private void cusume() {
        while (true) {
            try {
                // 取出数据
                int count = (int) queue.take();
                System.out.println("customer正在消费第" + count + "个商品===");
                // 只是为了方便观察输出结果
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class Productor implements Runnable {
    private BlockingQueue<Integer> queue;
    private int count = 1;

    Productor(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        this.product();
    }

    private void product() {
        while (true) {
            try {
                // 放入数据
                queue.put(count);
                System.out.println("生产者正在生产第" + count + "个商品");
                count++;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
